Method and apparatus for system maintenance on an image in a distributed data processing system

ABSTRACT

A method and apparatus for maintaining a client computer. An image of a selected client computer is created. The image of the selected client computer is placed on another computer. Maintenance is performed on the image on the another computer, wherein an updated image is created. The updated image is sent back to the client computer, wherein maintenance is performed.

CROSS REFERENCE TO RELATED APPLICATIONS

The present invention is related to application entitled Method And Apparatus For Installing Applications In A Distributed Data Processing System, Ser. No. 09/292,687, filed even date hereof, assigned to the same assignee, and incorporated herein by reference.

BACKGROUND OF THE INVENTION

1. Technical Field

The present invention relates generally to an improved distributed data processing system and in particular to an improved method and apparatus for maintaining a distributed data processing system. Still more particularly, the present invention provides a method and apparatus for maintaining images in a distributed data processing system.

2. Description of Related Art

In the early 1980s, as the first PC's were sold, people in the Information Systems (IS) industry thought that PC's might replace mainframe computers and cut operating costs drastically. Over the years, as personal computers gained more functionality and better user interfaces, end-users improved their productivity and ability to generate data. While enterprise data and legacy applications were still placed on the more reliable mainframe platforms, there was more and more need for distributed access to application and data resources.

The IS industry succeeded in connecting the two worlds of PC's and mainframes by implementing a client/server model with distributed databases. With the evolution of multi-platform applications over a variety of networking infrastructures, it appeared that PC's might replace mainframe computers. However, as people in the IS industry realized the immense overall costs of this approach, the client/server model evolved in many directions.

The choice of a wider variety of computer platforms improves the enterprise's ability to make appropriate investments in the evolving computing marketplace. The following is a description of various computer platforms and some of their characteristics.

Non-Programmable Terminals (NPT's) are often found in large enterprises connected to host-based applications systems. With the NPT, the user interface is managed and controlled by the central processing system. Historically, these terminals were the first to bring end-user access to information in the enterprise's central databases.

Network Computers (NC's), often based on RISC processors, offer greater versatility than NPT's because they have a built-in capability to run emulation software and to provide access to technologies such as Java™ and Windows™-based applications, such as browsers. NC's are typically implemented with only a general purpose processor, a system memory, and a communications port. Although other types of peripheral devices may be included, local drives, such as hard disk and floppy drives, are characteristically absent from such data processing systems. While the primary reason for not providing a local drive within such data processing systems is cost-saving, other reasons may include low-power requirement and compactness. Therefore, NC's typically rely upon network access to provide dynamic, non-volatile data storage capability. Managed PC's provide an Intel-based (or compatible) hardware platform that offers one the ability to run network computing operating systems. NC's and managed PC's are very similar. The major difference is that NC's generally have sealed cases and are not user up-gradeable, while managed PC's have locked covers and can be upgraded.

Traditional PC's, such as desktop and laptop PC's, are designed to offer highly sophisticated end-user environments. People who travel a lot, or who work at various locations, may use laptop PC's that require local, nonvolatile storage devices and a fully functional set of applications wherever they are, whether or not there is network connection available. The installation of workgroup computing software and complete application suites requires a powerful machine with significant local networking capabilities.

Each of the various network computing platforms has advantages and disadvantages. NPT's have the advantage of presenting a standard platform to each user. However, as users become more technically sophisticated through everyday use of various computing devices, users demand more options in their access to data and to computing resources, which may not be available through the use of NPT's. Managed PC's may have the ability to be tailored for sophisticated users, but as their name implies, managed PC's are purposely restricted in the number and variety of the software applications and hardware configurations which are presented to the user.

Traditional PC's on a network have the advantage of providing extensive flexibility. In order to accommodate their need for computing resources, users may add peripherals and software applications directly to a PC, while a network administrator may provide other resources on the network for many users in a common fashion. The disadvantages include the immense burden placed on a network or system administrator in ensuring that the various PC's retain some semblance of a standard configuration. Certain operating systems, such as Microsoft Windows NT, provide various levels of system administration capabilities for accomplishing such tasks. However, enormous costs and amounts of time may be spent in accommodating user preferences while ensuring corporate directives for the use of standard configurations.

One of the main advantages of network computing is the any-to-any type of connectivity between applications without having to worry about the hardware or software platforms in use. Network computing can be described as the use of different open technologies providing connectivity, ease-of-use, application functionality, information access, scalability, and systems management across widely dispersed types of networks. By making use of open standard technologies, network computing provides many advantages of the client/server paradigm while avoiding its numerous disadvantages. This goal could be achieved by the implementation of standards on all the platforms involved, such as TCP/IP, for the networking protocol, and 100% pure Java™ applications, in the hope that it will lead to truly portable applications, and solutions where in the network computing environment, all devices are able to easily communicate with one another.

With managed PCs in a network computing environment, the client's disk image is a remote image from a server. Installing applications at these PCs are a difficult and time consuming task. The difficulty lies partly in the fact that the user of the PC is typically not well versed in the data processing system and application dependencies. Further, most users are not well prepared to administer and support installation problems. The installation and support of applications usually entails a large degree of expertise and time. As a result, an IS or other network manager is usually in charge of installing and maintaining applications on PCs in a network computing environment. Performing application maintenance on PCs in a network requires the network manager to travel to each PC requiring maintenance. When a patch to fix a problem in a program is applicable to all PCs in a network, the network manager must travel to each PC to install the patch and test the system to see if the patch fixes the problem. This type of maintenance is time consuming, especially when in many cases PCs requiring maintenance may be located on different floors, different buildings, or even in different cities.

Thus, it would be advantageous to have an improved method and apparatus for providing maintenance to computers in a network computing environment.

SUMMARY OF THE INVENTION

The present invention provides a method and apparatus for maintaining a client computer. An image of a selected client computer is created. The image of the selected client computer is placed on another computer. Maintenance is performed on the image on another computer, wherein an updated image is created. The updated image is sent back to the client computer after maintenance is performed on the image.

BRIEF DESCRIPTION OF THE DRAWINGS

The novel features believed characteristic of the invention are set forth in the appended claims. The invention itself, however, as well as a preferred mode of use, further objectives and advantages thereof, will best be understood by reference to the following detailed description of an illustrative embodiment when read in conjunction with the accompanying drawings, wherein:

FIG. 1 depicts a pictorial representation of a distributed data processing system in which the present invention may be implemented;

FIG. 2 is a block diagram depicting a data processing system, which may be implemented as a server, in accordance with a preferred embodiment of the present invention;

FIG. 3 is a block diagram illustrating a data processing system in which the present invention may be implemented;

FIGS. 4A-4C are diagrams illustrating the system maintenance on an image on a client computer depicted in accordance with a preferred embodiment of the present invention;

FIG. 5 is a diagram of an image depicted in accordance with a preferred embodiment of the present invention;

FIG. 6 is a flowchart for creating an image for a client depicted in accordance with a preferred embodiment of the present invention;

FIG. 7 is a flowchart of a process for installing an application depicted in accordance with a preferred embodiment of the present invention;

FIG. 8 is a flowchart of a process for creating a snapshot of an image depicted in accordance with a preferred embodiment of the present invention;

FIG. 9 is a flowchart of a process for sending a snapshot image to a client depicted in accordance with a preferred embodiment of the present invention; and

FIG. 10 is a flowchart of a process used by a client to receive a snapshot image depicted in accordance with a preferred embodiment of the present invention.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT

With reference now to the figures, FIG. 1 depicts a pictorial representation of a distributed data processing system in which the present invention may be implemented. Distributed data processing system 100 is a network of computers in which the present invention may be implemented. Distributed data processing system 100 contains a network 102, which is the medium used to provide communications links between various devices and computers connected together within distributed data processing system 100. Network 102 may include permanent connections, such as wire or fiber optic cables, or temporary connections made through telephone connections.

In the depicted example, a server 104 is connected to network 102 along with storage unit 106. In addition, clients 108, 110, and 112 also are connected to a network 102. These clients 108, 110, and 112 may be, for example, personal computers or network computers. For purposes of this application, a network computer is any computer, coupled to a network, which receives a program or other application from another computer coupled to the network. In the depicted example, server 104 provides data, such as boot files, operating system images, and applications to clients 108-112. Clients 108, 110, and 112 are clients to server 104. Distributed data processing system 100 may include additional servers, clients, and other devices not shown. In the depicted example, distributed data processing system 100 is the Internet with network 102 representing a worldwide collection of networks and gateways that use the TCP/IP suite of protocols to communicate with one another. At the heart of the Internet is a backbone of high-speed data communication lines between major nodes or host computers, consisting of thousands of commercial, government, educational and other computer systems that route data and messages. Of course, distributed data processing system 100 also may be implemented as a number of different types of networks, such as for example, an intranet, a local area network (LAN), or a wide area network (WAN). FIG. 1 is intended as an example, and not as an architectural limitation for the present invention.

Referring to FIG. 2, a block diagram depicts a data processing system, which may be implemented as a server, such as server 104 in FIG. 1, in accordance with a preferred embodiment of the present invention. Data processing system 200 may be a symmetric multiprocessor (SMP) system including a plurality of processors 202 and 204 connected to system bus 206. Alternatively, a single processor system may be employed. Also connected to system bus 206 is memory controller/cache 208, which provides an interface to local memory 209. I/O bus bridge 210 is connected to system bus 206 and provides an interface to I/O bus 212. Memory controller/cache 208 and I/O bus bridge 210 may be integrated as depicted.

Peripheral component interconnect (PCI) bus bridge 214 connected to I/O bus 212 provides an interface to PCI local bus 216. A number of modems may be connected to PCI bus 216. Typical PCI bus implementations will support four PCI expansion slots or add-in connectors. Communications links to network computers 108-112 in FIG. 1 may be provided through modem 218 and network adapter 220 connected to PCI local bus 216 through add-in boards.

Additional PCI bus bridges 222 and 224 provide interfaces for additional PCI buses 226 and 228, from which additional modems or network adapters may be supported. In this manner, server 200 allows connections to multiple network computers. A memory-mapped graphics adapter 230 and hard disk 232 may also be connected to I/O bus 212 as depicted, either directly or indirectly.

Those of ordinary skill in the art will appreciate that the hardware depicted in FIG. 2 may vary. For example, other peripheral devices, such as optical disk drives and the like, also may be used in addition to or in place of the hardware depicted. The depicted example is not meant to imply architectural limitations with respect to the present invention.

The data processing system depicted in FIG. 2 may be, for example, an IBM RISC/System 6000 system, a product of International Business Machines Corporation in Armonk, N.Y., running the Advanced Interactive Executive (AIX) operating system.

With reference now to FIG. 3, a block diagram illustrates a data processing system in which the present invention may be implemented. Data processing system 300 is an example of a client computer. Data processing system 300 employs a peripheral component interconnect (PCI) local bus architecture. Although the depicted example employs a PCI bus, other bus architectures such as Micro Channel and ISA may be used. Processor 302 and main memory 304 are connected to PCI local bus 306 through PCI bridge 308. PCI bridge 308 also may include an integrated memory controller and cache memory for processor 302. Additional connections to PCI local bus 306 may be made through direct component interconnection or through add-in boards. In the depicted example, local area network (LAN) adapter 310, SCSI host bus adapter 312, and expansion bus interface 314 are connected to PCI local bus 306 by direct component connection. In contrast, audio adapter 316, graphics adapter 318, and audio/video adapter 319 are connected to PCI local bus 306 by add-in boards inserted into expansion slots. Expansion bus interface 314 provides a connection for a keyboard and mouse adapter 320, modem 322, and additional memory 324. SCSI host bus adapter 312 provides a connection for hard disk drive 326, tape drive 328, and CD-ROM drive 330. Typical PCI local bus implementations will support three or four PCI expansion slots or add-in connectors.

An operating system runs on processor 302 and is used to coordinate and provide control of various components within data processing system 300 in FIG. 3. The operating system may be a commercially available operating system such as OS/2, which is available from International Business Machines Corporation. “OS/2” is a trademark of International Business Machines Corporation. An object oriented programming system such as Java may run in conjunction with the operating system and provides calls to the operating system from Java programs or applications executing on data processing system 300. “Java” is a trademark of Sun Microsystems, Inc. Instructions for the operating system, the object-oriented operating system, and applications or programs are located on storage devices, such as hard disk drive 326, and may be loaded into main memory 304 for execution by processor 302.

Those of ordinary skill in the art will appreciate that the hardware in FIG. 3 may vary depending on the implementation. Other internal hardware or peripheral devices, such as flash ROM (or equivalent nonvolatile memory) or optical disk drives and the like, may be used in addition to or in place of the hardware depicted in FIG. 3. Also, the processes of the present invention may be applied to a multiprocessor data processing system.

For example, data processing system 300, if optionally configured as a network computer, may not include SCSI host bus adapter 312, hard disk drive 326, tape drive 328, and CD-ROM 330, as noted by dotted line 332 in FIG. 3 denoting optional inclusion. In that case, the computer, to be properly called a client computer, must include some type of network communication interface, such as LAN adapter 310, modem 322, or the like. As another example, data processing system 300 may be a stand-alone system configured to be bootable without relying on some type of network communication interface, whether or not data processing system 300 comprises some type of network communication interface. As a further example, data processing system 300 may be a Personal Digital Assistant (PDA) device which is configured with ROM and/or flash ROM in order to provide non-volatile memory for storing operating system files and/or user-generated data.

The depicted example in FIG. 3 and above-described examples are not meant to imply architectural limitations.

The present invention provides a method, apparatus, and instructions for system maintenance of computers in a network. This system maintenance may be performed without requiring the network manager or technician to travel from one computer to another. A copy of the client system's operating environment is made. This copy is also referred to as a snapshot image and is typically a copy of the persistent storage at the computer. System maintenance for the client is performed using the snapshot image. This may be accomplished at a computer near or convenient to the installer without requiring the installer to travel to the computer. When the system maintenance is complete, the image may be returned to the computer over the network.

With reference now to FIGS. 4A-4C, diagrams illustrating the system maintenance on an image on a client computer is depicted in accordance with a preferred embodiment of the present invention. In FIG. 4A, server 400 is in communication with client 402 via communications link 404. Client 402 includes image 406, which is a complete collection of the user operating environment, including for example, system memory, disk images, register images, connection to remote devices, and network and processor states. A snapshot or copy of image 406 is made from client 402 to form a snapshot image, which is stored on server 400. Server 400 may store a number of snapshot images 408, 410, and 412 for clients requiring system maintenance in the depicted example. These images may include updated images that have had system maintenance performed. The area in which these snapshot images are stored is also referred to as a “staging area”. A snapshot image of client 402 is a copy of the user's operating environment on client 402 as represented by image 406. This snapshot image may be of the entire operating environment or may be only that of the persistent storage depending on the implementation. This snapshot image is made when system maintenance is to be performed on a client, such as client 402. The snapshot image may be created by the client sending incremental portions of the operating environment to the server until a complete image is stored on the server. In the depicted example, snapshot image 410 is a copy of image 406 on client 402.

Each user has an account on server 400 stored in user file 414. In the depicted example, this file includes a user ID, a machine type for the user client, and an identification of the location and/or space allocated for the snapshot image. This user file is used to track snapshot images for clients on which system maintenance is being performed. When a snapshot image is updated, the information in user file 414 will be used to return the snapshot image to the appropriate client.

In the depicted example, one of the snapshot images on server 400 is copied onto client 416 to form snapshot image 418. This snapshot image is to perform system maintenance for a client. For example, patches or updates to operating systems or applications used by the client may be made during system maintenance. Disk defragmentation, virus scanning, virus removal along with changes to port settings or other system settings, such as memory management are some examples of system maintenance that may be performed on an image. When the system maintenance has been completed, an updated snapshot image 420 is present in client 416 as shown in FIG. 4B. In the depicted example, section 422 in image 420 contains the any changes, updates, or patches to be used by the client from which the snapshot originated. Then, snapshot image 420 is returned to server 400 as illustrated in FIG. 4C. In this example, snapshot image 420 replaces snapshot image 410, which is the snapshot image associated with client 402. The updated image as reflected by snapshot image 420 is then returned to client 402 using the information in user file 414 to return this updated snapshot image. This snapshot image is then used on client 402 in place of the original image, image 406. The user at client 402 now may have use of any changes or updates performed during system maintenance without requiring an installer or technician to physically travel to client 402 to perform the system maintenance. In this example, the system maintenance is performed on a client, such as client 416, that is close by or local to the installer. The client selected for the installation is usually of the same machine type and having the same configuration as the client from which the snapshot image was taken. Alternatively, the system maintenance may actually take place on server 400. In such a case, server 400 includes an emulation of the client system on which the system maintenance is to be performed.

With reference to FIG. 5, a diagram of an image is depicted in accordance with a preferred embodiment of the present invention. Image 500 is an example of an image on a client, such as image 406 on client 402 in FIG. 4. Image 500 may be stored as a snapshot image on a server such as server 400 in FIG. 4. Image 500 is an image used to place a computer, such as client 402, into a selected state. Image 500 in this example includes header information 502, state information 504, and paging file information 506. Header information 502 describes the file layout and loading information for the image on the client, while state information 504 contains the state of the physical memory and hardware devices within the client (i.e. devices used by the operating system, interrupts, and network based real time clock). State information 504 may be obtained using known hibernation techniques, such as those described in U.S. Pat. No. 5,822,582. The state information may be useful to identify various conflicts or errors during system maintenance.

Image 500 will include paging file information 506 only for systems involving virtual memory management. Paging file information within image 500 may be the paging file itself. Alternatively, a part of the paging file may be frozen or locked from changes in which the locked portion of the paging file contains information needed to restore, boot, or unhibernate the client. Although the depicted example employs a paging file, a paging space may be used in place of a paging file depending on the type of operating system. A paging space or paging file is applicable to systems with virtual memory managers.

Alternatively, snapshot image 500 may omit state information 504 and contain only paging file information 506, which is in essence the information located on persistent storage, such as a hard disk drive.

With reference now to FIG. 6, a flowchart for creating an image for a client is depicted in accordance with a preferred embodiment of the present invention. The process begins by installing system programs for the client on the server (step 600). Thereafter, application programs are installed for the client on the server (step 602). In these examples, system programs include base operating systems and extensions, such as Windows 95 and Network drivers. Application programs in these depicted examples are, for example, after market add-ons, such as word processors, data base programs, and spread sheets. Then, an image is created for the client (step 604). Thereafter, the image is loaded on to the client (step 606) with the process then terminating. Sometime after the image has been loaded on the client, system maintenance may be required to fix problems or provide updates. The details of these processes are described in more detail below.

With reference now to FIG. 7, a flowchart of a process for system maintenance on an image is depicted in accordance with a preferred embodiment of the present invention. The process begins by creating a snapshot image of the operating environment on the client (step 700). This step is accomplished by having the client send a copy of the paging file and possibly state information to the server. Thereafter, this snapshot image is loaded onto a staging area within a server (step 702).

This snapshot image is loaded or started on a network computer in a service environment (step 704). This network computer is selected to have a configuration that is identical to that of the client from which the image was taken. System maintenance on the image is performed (step 706). This system maintenance may include, for example, applying updates and/or patches to the client operating system or applications. Also, system maintenance may include resolving various conflicts for memory and other resources within the client. This information may be identified and resolved using state information in the snapshot image. The updated snapshot image may then be tested (step 708). Next, a determination is made as to whether the client is active (step 710). This step is used to determine whether the client that is to receive the updated snapshot image is turned on so that the snapshot image can be sent to the client.

If the client is active, the updated snapshot image is then queued for commit to the server (step 712) with the process terminating thereafter. In the depicted examples, a commit occurs after the system administrator or other IS person completes testing and starts the process to update the running client systems (i.e. server file). With reference again to step 710, if the client is not active, then the updated image is committed to the server for deliver to the client (step 714). This step causes delivery of the image to be scheduled for when the client becomes active.

The processes illustrated in FIG. 7 may be performed for each client requiring maintenance. If all of the clients have identical images (i.e., the same system and application programs), then the system maintenance performed on one image may be distributed to all clients matching the client on which the maintenance was performed.

With reference now to FIG. 8, a flowchart of a process for creating a snapshot of an image is depicted in accordance with a preferred embodiment of the present invention. The process in FIG. 8 may be implemented in a server to obtain a snapshot image of the client for use in installing one or more new applications. This process of creating a snapshot image may be performed at a number of different times. For example, the image may be taken at a checkpoint, such as, at logoff, application termination, application initiation, etc.

The process begins by requesting a snapshot image from the client (step 800). Thereafter, the process waits to receive the snapshot image data from the client (step 802). When snapshot image data is received, a determination is made as to whether the snapshot image is complete (step 804). If the snapshot image is complete, this image is stored (step 806) and an entry is made in the user file to reflect the presence of the snapshot image (step 808) with the process terminating thereafter.

With reference again to step 804, if the snapshot image is not complete, the process returns to step 800 to receive snapshot image data.

Turning next to FIG. 9, a flowchart of a process for sending a snapshot image to a client is depicted in accordance with a preferred embodiment of the present invention. This process may be used by a server to return an updated snapshot image to the client. In returning a snapshot image to a client, the depicted example employs a mechanism, such as remote initial program load (RIPL), which is typically used to load an operating system from a server to a client. This process as well as other mechanisms may be used to send the updated snapshot image to the client.

The process begins by identifying a client with an updated snapshot image (step 900). The process then wakes up the client if the client is not active or is in a suspend mode (step 902). If needed, a bootstrap program is sent to the client (step 904). The sending of the bootstrap image is part of the mechanism, such as that used by RIPL. The process then sends the updated snapshot image to the client (step 906). A determination is then made as to whether additional updated snapshot images are present to be sent back to clients (step 908). If additional updated images are present, the process returns to step 900. Otherwise, the process terminates.

Turning next to FIG. 10, a flowchart of a process used by a client to receive a snapshot image is depicted in accordance with a preferred embodiment of the present invention. The process begins by the client returning a network read request, which is sent on to the network (step 1000). Thereafter, the client receives a bootstrap program and an IP address from the network (step 1002). The client then finds the server to which the client is assigned (step 1004). The assignment of the server may be obtained from information stored locally at the client in a device, such as a flash RAM. Thereafter, the client is authorized for access to the server (step 1006). The snapshot image is then received (step 1008) with the process terminating thereafter. In the depicted examples in FIGS. 9 and 10, the same server is used to place the client onto the network as well as to return the snapshot image to the client. Depending on the implementation, one server or computer may be used to wake up or place the client on the network, such as a RIPL server with another server being used to return the snapshot image.

It is important to note that while the present invention has been described in the context of a fully functioning data processing system, those of ordinary skill in the art will appreciate that the processes of the present invention are capable of being distributed in the form of a computer readable medium of instructions and a variety of forms and that the present invention applies equally regardless of the particular type of signal bearing media actually used to carry out the distribution. Examples of computer readable media include recordable-type media such a floppy disc, a hard disk drive, a RAM, and CD-ROMs and transmission-type media such as digital and analog communications links.

The description of the present invention has been presented for purposes of illustration and description, but is not intended to be exhaustive or limited to the invention in the form disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art. The embodiment was chosen and described in order to best explain the principles of the invention, the practical application, and to enable others of ordinary skill in the art to understand the invention for various embodiments with various modifications as are suited to the particular use contemplated. 

What is claimed is:
 1. A method for maintaining a client computer, the method comprising the computer implemented steps of: creating an image of a selected client computer; placing the image of the selected client computer on another computer; performing maintenance on the image on the another computer, wherein an updated image is created; and sending the updated image back to the client computer, wherein maintenance is performed.
 2. The method of claim 1, wherein the step of performing maintenance includes: testing the updated image prior to sending the updated image back to the client computer.
 3. The method of claim 1, wherein the step of sending the updated image back to the client computer includes using a remote method to reset the computer and load the updated image onto the client computer.
 4. The method of claim 1, wherein the another computer is a client computer matching the selected client computer.
 5. The method of claim 1, wherein the another computer is a server computer running an emulation of the selected client computer.
 6. The method of claim 1, wherein the client computer includes a disk and wherein the image is an image of the disk.
 7. The method of claim 1, wherein the client computer includes a disk and volatile memory wherein the image is an image of content of the disk and the volatile memory.
 8. A method for maintaining an image of a data processing system, the method comprising the data processing system implemented steps of: creating images of operating environments for a plurality of client computers requiring maintenance; performing maintenance on the images to form a set of updated images; and returning the set of updated images to the plurality of client computers.
 9. The method of claim 8, wherein the another computer is another client computer.
 10. The method of claim 8, wherein the step of performing maintenance includes: testing the image prior to returning the set of updated images.
 11. The method of claim 8, wherein the step of returning the set of updated images includes placing the updated images on a server for distribution to the plurality of client computers.
 12. A distributed data processing system comprising: a network a plurality of client computers connected to the network; and a server computer connected to the network, wherein the server computer receives a snapshot image of a client computer within the plurality of client computers, allows for maintenance of the client using the snapshot image, creates an updated snapshot image after maintenance has been performed on the snapshot image, and returns the updated snapshot image to the client computer.
 13. The distributed data processing system of claim 12, wherein the client computer is a first client computer and wherein the server loads the snapshot image onto a second client computer for performing maintenance on the snapshot image.
 14. A data processing system for maintaining a client computer, the data processing system comprising: creating means for creating an image of a selected client computer; placing means for placing the image of the selected client computer on another computer; performing means for performing maintenance on the image on the another computer, wherein an updated image is created; and sending means for sending the updated image back to the client computer, wherein maintenance is performed.
 15. The data processing system of claim 14, wherein the performing means of performing maintenance includes: testing means for testing the updated image prior to sending the updated image back to the client computer.
 16. The data processing system of claim 14, wherein the sending means for sending the updated image back to the client computer includes using a remote method to reset the computer and load the updated image onto the client computer.
 17. The data processing system of claim 16, wherein the another computer is a client computer matching the selected client computer.
 18. The data processing system of claim 14, wherein the another computer is a server computer running an emulation of the selected client computer.
 19. The data processing system of claim 14, wherein the client computer includes a disk and wherein the image is an image of the disk.
 20. The data processing system of claim 14, wherein the client computer includes a disk and volatile memory wherein the image is an image of content of the disk and the volatile memory.
 21. A data processing system for maintaining an image of a data processing system, the data processing system comprising: creating means for creating images of operating environments for a plurality of client computers requiring maintenance; performing means for performing maintenance on the images to form a set of updated images; and returning means for returning the set of updated images to the plurality of client computers.
 22. The data processing system of claim 21, wherein the another computer is another client computer.
 23. The data processing system of claim 21, wherein the performing means for performing maintenance includes: testing means for testing the image prior to returning the set of updated images.
 24. The data processing system of claim 21, wherein the returning means for returning the set of updated images includes placing the updated images on a server for distribution to the plurality of client computers.
 25. A computer program product in a computer readable medium for maintaining a client computer, the computer program product comprising: first instructions for creating an image of a selected client computer; second instructions for placing the image of the selected client computer on another computer; third instructions for performing maintenance on the image on the another computer, wherein an updated image is created; and fourth instructions for sending the updated image back to the client computer, wherein maintenance is performed.
 26. A computer program product in a computer readable medium for maintaining an image of a data processing system, the computer program product comprising: first instructions for creating images of operating environments for a plurality of client computers requiring maintenance; second instructions for performing maintenance on the images to form a set of updated images; and third instructions for returning the set of updated images to the plurality of client computers. 